home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / util / cdity / ModeProSrc.lha / Daemon / MPNodes.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-13  |  3.4 KB  |  176 lines
  1. #include "MP.h"
  2.  
  3. /*
  4.     mprefs will hold a shared lock on ListSem,
  5.     mpatch will obatin a shared lock
  6.     
  7.     RemDNode & AddDNode must get a normal lock
  8. */
  9.  
  10. extern struct MPSem *MPSem;
  11.  
  12. void RemDNode(struct DefaultNode *DN)
  13. {
  14.   if(DN)
  15.   {
  16.     Forbid();
  17.     SendPrefsMsg(MP_LISTSTATUS, MPLS_UPDATING, 0);
  18.     ObtainSemaphore(&MPSem->ListSem); // maybe shared with prefs
  19.     ObtainSemaphore(&MPSem->NodeSem);
  20.     Remove((struct Node *)DN);
  21.     ReleaseSemaphore(&MPSem->NodeSem);
  22.     ReleaseSemaphore(&MPSem->ListSem);
  23.     Permit();
  24.  
  25.     SendPrefsMsg(MP_LISTSTATUS, MPLS_NORMAL, 0);
  26.     SendPrefsMsg(MP_REMNODE,0,DN);
  27.     FreeDNode(DN);
  28.   }
  29. }
  30.     
  31. void AddDNode(ULONG dest, struct DefaultNode *n)
  32. {
  33.   if(dest < 4 && n)
  34.   {
  35.     Forbid();
  36.     SendPrefsMsg(MP_LISTSTATUS, MPLS_UPDATING, 0);
  37.     ObtainSemaphoreShared(&MPSem->ListSem); // maybe shared with prefs
  38.     ObtainSemaphore(&MPSem->NodeSem);
  39.     AddHead(&MPSem->PromotionList[dest],(struct Node *)n);
  40.     n->Depth=max(1,n->Depth);
  41.     ReleaseSemaphore(&MPSem->NodeSem);
  42.     ReleaseSemaphore(&MPSem->ListSem);
  43.     Permit();
  44.   
  45.     MPSem->LVActive=0;
  46.     MPSem->CurrentList=dest;
  47.     
  48.     SendPrefsMsg(MP_LISTSTATUS, MPLS_NORMAL, 0);
  49.     SendPrefsMsg(MP_NEWNODE,dest,n);
  50.     SendPrefsMsg(MP_SAVE,0,0);
  51.   }
  52.   else
  53.     FreeDNode(n);
  54. }
  55.  
  56. struct DefaultNode *FindDNode(struct List *list,UBYTE *name)
  57. {
  58.   struct DefaultNode *dn;
  59.   UWORD l;
  60.   UBYTE str[128],patsrc[128];
  61.   UBYTE pat[258];
  62.  
  63.   
  64.   if(IsListEmpty(list))
  65.   {
  66.     return(NULL);
  67.   }
  68.   
  69.   
  70.   l=0;
  71.   if(name) // 4.55 @1
  72.   {
  73.     for(l=0;l<127 && name[l];l++)
  74.     {
  75.       str[l]=ToUpper(name[l]);
  76.     }
  77.   }
  78.   str[l]=0;
  79.  
  80.   dn=(struct DefaultNode *)list->lh_Head;
  81.   while(dn && dn->Def_Node.ln_Succ!=0)
  82.   {
  83.     for(l=0;l<127 && dn->Def_Node.ln_Name[l];l++)
  84.       patsrc[l]=ToUpper(dn->Def_Node.ln_Name[l]);
  85.     patsrc[l]=0;
  86.       
  87.     ParsePatternNoCase(patsrc,pat,258);
  88.     
  89.     if(MatchPatternNoCase(pat,name))
  90.       return(dn);
  91.     dn=(struct DefaultNode *)dn->Def_Node.ln_Succ;
  92.   }
  93.   return(NULL);
  94. }
  95.  
  96.  
  97. struct DefaultNode *Find_SMNode(struct List *list, STRPTR name, ULONG ModeID)
  98. {
  99.   struct DefaultNode *dn;
  100.   UWORD l,l2;
  101.   UBYTE str[128],patsrc[128];
  102.   UBYTE pat[258];
  103.  
  104.   
  105.   if(IsListEmpty(list))
  106.   {
  107.     return(NULL);
  108.   }
  109.   
  110.   l=0;
  111.   if(name)
  112.   {
  113.     for(l=0;l<127 && name[l];l++)
  114.       str[l]=ToUpper(name[l]);
  115.  
  116.   }
  117.   str[l]=0;
  118.   
  119.   dn=(struct DefaultNode *)list->lh_Head;
  120.   while(dn && dn->Def_Node.ln_Succ!=0)
  121.   {
  122.     if(ModeID!=INVALID_ID)//                                                                           (4.56.8)
  123.     {
  124.       if((dn->OrigDisplayID ==  ModeID) || (dn->OrigDisplayID == (ModeID | ALL_MODES)) )     
  125.       {
  126.         return(dn);
  127.       }
  128.     }
  129.  
  130.     l=l2=0;
  131.     
  132.     while(l2<126 && dn->Def_Node.ln_Name[l])
  133.     {
  134.       if(dn->Def_Node.ln_Name[l]==' ')
  135.       {
  136.         patsrc[l2]='#';
  137.         l2++;
  138.       }
  139.       patsrc[l2]=ToUpper(dn->Def_Node.ln_Name[l]);
  140.       l++;
  141.       l2++;
  142.     }
  143.     patsrc[l2]=0;
  144.  
  145.     ParsePatternNoCase(patsrc,pat,258);
  146.    
  147.     if(MatchPatternNoCase(pat,name))
  148.       return(dn);
  149.       
  150.     dn=(struct DefaultNode *)dn->Def_Node.ln_Succ;
  151.   }
  152.   return(NULL);
  153. }
  154.  
  155. /*
  156. BOOL MatchString(STRPTR Pattern, STRPTR String)
  157. {
  158.   struct DefaultNode *dn;
  159.   UWORD l;
  160.   UBYTE str[128],patsrc[128];
  161.   UBYTE pat[258];
  162.   
  163.   for(l=0;l<127 && String[l];l++)
  164.     str[l]=ToUpper(String[l]);
  165.   str[l]=0;
  166.  
  167.   for(l=0;l<127 && Pattern[l];l++)
  168.     patsrc[l]=ToUpper(Pattern[l]);
  169.   patsrc[l]=0;
  170.       
  171.   ParsePatternNoCase(patsrc,pat,258);
  172.     
  173.   return(MatchPatternNoCase(pat,String));
  174. }
  175. */
  176.